/**
 * 作者：
 * 创建时间：2012-6-28 上午9:29:48
 */
package dragon.model.bizObject;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import dragon.core.exception.ExceptionHandler;
import dragon.core.io.FileHandler;
import dragon.core.io.XMLHandler;
import dragon.core.util.FilePath;
import dragon.core.util.Reflect;
import dragon.core.util.StringUtils;
import dragon.model.base.ModelSort;
import dragon.model.base.Util;
import dragon.model.fieldTemplate.FieldTemplate;
import dragon.model.fieldTemplate.FieldTemplateContainer;
import dragon.model.fieldTemplate.FieldTemplateType;
import dragon.model.intercept.Interceptor;
import dragon.model.table.Field;
import dragon.model.table.Table;
import dragon.model.table.TableContainer;

/**
 * 业务模型解析
 */
public class BizObjectParser {

	/**
	 * 日志对象
	 */
	private static Logger logger = LoggerFactory.getLogger(BizObjectParser.class);

	/**
	 * 解析业务模型对象
	 * 
	 * @param filePath
	 *            业务模型xml配置文件路径
	 * @return
	 * @throws ExceptionHandler
	 */
	@SuppressWarnings("unchecked")
	public static BizObject parse(String filePath) throws ExceptionHandler {

		// 构造文件路径
		if (logger.isDebugEnabled()) {
			logger.debug("获取业务模型，文件路径：" + filePath + " 存在：" + FileHandler.isFileExists(filePath));
		}

		// 文件不存在
		if (!FileHandler.isFileExists(filePath)) {
			return null;
		}

		// 解析文件内容，映射到对象
		List<Map<String, Object>> list = XMLHandler.readXML(filePath, "BizObject", null, true);
		if (list == null || list.size() == 0) {
			return null;// 文件不是有效的模型定义文件
		}

		BizObject bizObject = new BizObject();
		if (FilePath.MODEL_BIZOBJECT.length() > filePath.lastIndexOf(FilePath.separator)) {
			bizObject.setPkg("");
		} else {
			bizObject.setPkg(filePath.substring(FilePath.MODEL_BIZOBJECT.length(), filePath.lastIndexOf(FilePath.separator)));
		}

		// 获取BizObject标签下的子级标签内容，这里默认了一个文件只存储一个模型定义(TODO:后期可改 )
		List<Map<String, Object>> children = (List<Map<String, Object>>) list.get(0).get(XMLHandler.CHILDREN_KEY);
		String tagName = null;
		String textContent = null;
		for (Map<String, Object> map : children) {
			tagName = (String) map.get(XMLHandler.TAG_NAME_KEY);
			textContent = (String) map.get(XMLHandler.TEXT_CONTENT);
			if ("BizFields".equalsIgnoreCase(tagName)) {
				/* 字段定义 */
				bizObject.setBizFields(parseField(bizObject, map));
				// sort
				Collections.sort(bizObject.getBizFields(), new ModelSort());

				/*
				 * 1、字段分流，拆分冻结字段、非冻结字段和主键字段到相应属性
				 * 
				 * 2、计算 邻近的字段数量(BizField adjacentFieldsNum)和各行中最大的字段数量(BizObject maxFieldsNumPerRow)
				 */
				int adjacentFieldsNum = 0;
				int maxFieldsNumPerRow = 0;
				List<BizField> tempBizFields = new ArrayList<BizField>();
				for (BizField bizField : (List<BizField>) bizObject.getBizFields()) {
					/* 1、字段分流 */
					if (bizField.getIsListField() == 1) {
						if (bizField.getFrozen() == 1) {
							// 冻结字段
							if (bizObject.getBizFieldsBind().get("FROZEN") == null) {
								bizObject.getBizFieldsBind().put("FROZEN", new ArrayList<BizField>());
							}
							((List<BizField>) bizObject.getBizFieldsBind().get("FROZEN")).add(bizField);
						} else {
							// 非冻结字段
							if (bizObject.getBizFieldsBind().get("NONFROZEN") == null) {
								bizObject.getBizFieldsBind().put("NONFROZEN", new ArrayList<BizField>());
							}
							((List<BizField>) bizObject.getBizFieldsBind().get("NONFROZEN")).add(bizField);
						}
					}

					if (bizField.getIsPrimaryKey() == 1) {
						// 主键字段
						if (bizObject.getBizFieldsBind().get("PRIMARY") == null) {
							bizObject.getBizFieldsBind().put("PRIMARY", new ArrayList<BizField>());
						}
						((List<BizField>) bizObject.getBizFieldsBind().get("PRIMARY")).add(bizField);
					}

					/* 2、计算 */
					if (bizField.getIsVisible() == 1 && bizField.getIsFormField() == 1) {
						adjacentFieldsNum++;
						tempBizFields.add(bizField);

						// 换行的情况：1、br=1，2、字段模板类型为：LONGTEXT,RICHTEXT，3、最后一行
						if (bizField.getBr() == 1
								|| (bizField.getFieldTemplate() != null && (bizField.getFieldTemplate().getType().equals(FieldTemplateType.LONGTEXT) || bizField.getFieldTemplate().getType()
										.equals(FieldTemplateType.RICHTEXT)))) {
							if (adjacentFieldsNum > maxFieldsNumPerRow) {
								maxFieldsNumPerRow = adjacentFieldsNum;
							}
							for (BizField tempBizField : tempBizFields) {
								tempBizField.setAdjacentFieldsNum(adjacentFieldsNum);// 邻近的字段数量
							}
							tempBizFields.clear();
							adjacentFieldsNum = 0;
						}
					}

				}
				// 循环结束后，判断是否有未结束行
				if (adjacentFieldsNum > 0) {
					if (adjacentFieldsNum > maxFieldsNumPerRow) {
						maxFieldsNumPerRow = adjacentFieldsNum;
					}
					for (BizField tempBizField : tempBizFields) {
						tempBizField.setAdjacentFieldsNum(adjacentFieldsNum);// 邻近的字段数量
					}
					tempBizFields = null;
				}
				bizObject.setMaxFieldsNumPerRow(maxFieldsNumPerRow);// 行最大字段数量

				if (bizObject.getBizFieldsBind().get("FROZEN") != null) {
					// sort
					Collections.sort((List<BizField>) bizObject.getBizFieldsBind().get("FROZEN"), new ModelSort());
				}
				if (bizObject.getBizFieldsBind().get("NONFROZEN") != null) {
					// sort
					Collections.sort((List<BizField>) bizObject.getBizFieldsBind().get("NONFROZEN"), new ModelSort());
				}
				if (bizObject.getBizFieldsBind().get("PRIMARY") != null) {
					// sort
					Collections.sort((List<BizField>) bizObject.getBizFieldsBind().get("PRIMARY"), new ModelSort());
				}

			} else if ("QueryFields".equalsIgnoreCase(tagName)) {
				// 查询字段
				bizObject.setQueryFields(parseQueryField(bizObject, map));
			} else if ("BizProcesses".equalsIgnoreCase(tagName)) {
				// 业务过程
				bizObject.setProcesses(parseBizProcess(bizObject, map));
			} else if ("SQL".equalsIgnoreCase(tagName)) {
				/* SQL定义 */
				bizObject.setSql(parseSQL(map));

				// SQL分流
				Map<SQLType, String[]> sql = bizObject.getSql();
				String[] temp = null;

				// select
				temp = sql.get(SQLType.SELECT);
				if (temp != null) {
					bizObject.setSelectSQL(temp[0]);
				}

				// insert,updatequery,update,delete 语句在 bindSQLBizField 中处理

				temp = null;
				sql = null;
			} else if ("interceptor".equalsIgnoreCase(tagName)) {
				// 拦截器
				try {
					Object obj = Class.forName(textContent).newInstance();
					if (obj != null) {
						bizObject.setInterceptor((Interceptor) obj);
					}
					obj = null;
				} catch (ClassNotFoundException e) {
					throw new ExceptionHandler(String.format("业务模型 %s[%s] 指定的拦截器类 %s 不存在！", bizObject.getName(), bizObject.getCode(), bizObject.getInterceptor()));
				} catch (InstantiationException e) {
					throw new ExceptionHandler(String.format("解析业务模型 %s[%s] 拦截器 %s 出错！", bizObject.getName(), bizObject.getCode(), bizObject.getInterceptor()), e);
				} catch (IllegalAccessException e) {
					throw new ExceptionHandler(String.format("解析业务模型 %s[%s] 拦截器 %s 出错！", bizObject.getName(), bizObject.getCode(), bizObject.getInterceptor()), e);
				}
			} else if (!StringUtils.isEmpty(tagName)) {
				/* 基本属性 */
				Util.dynamicAssignment(bizObject, tagName, textContent);
			}
		}

		// 如果配置了dnd，且采用默认的TREE页面，则必须同时配置dndAction
		if (bizObject.getDnd() == 1 && "TREE".equals(bizObject.getTreePage())) {
			if (StringUtils.isEmpty(bizObject.getDndAction())) {
				throw new ExceptionHandler(String.format("业务模型 %s[%s] 采用了树形主从结构，启用了dnd功能，且采用了默认的TREE页面，但是没有配置dndAction！", bizObject.getName(), bizObject.getCode()));
			}
		}

		// 是否有文件字段
		FieldTemplate fieldTemplate = null;
		for (BizField bizField : (List<BizField>) bizObject.getBizFields()) {
			fieldTemplate = bizField.getFieldTemplate();
			if (fieldTemplate != null && fieldTemplate.getType() == FieldTemplateType.FILE) {
				bizObject.setHasFileField(true);
				break;
			}
		}
		fieldTemplate = null;

		// 如果字段中有文件字段，则必须定义主键(因为文件最终都保存在系统文件表中t_sys_file，需要关联实例对象)
		if (bizObject.getBizFieldsBind().get("PRIMARY") == null && bizObject.isHasFileField()) {
			throw new ExceptionHandler(String.format("业务模型 %s[%s] 缺少 主键(字段引用了FILE类型的字段模板时，必须定义主键)！", bizObject.getName(), bizObject.getCode()));
		}

		// 绑定sql中的字段
		bindSQLBizField(bizObject);

		// 如果定义了update语句而没有定义updatequery语句，则报错
		if (bizObject.getUpdateSQL() != null && bizObject.getUpdateQuerySQL() == null) {
			throw new ExceptionHandler(String.format("业务模型 %s[%s] 缺少 UPDATEQUERY 语句！", bizObject.getName(), bizObject.getCode()));
		}

		// 业务过程排序(因为bindSQLBizField涉及到业务过程，所以排序放在这里进行)
		if (bizObject.getProcesses() != null) {
			Collections.sort(bizObject.getProcesses(), new ModelSort());
		}

		// 如果业务操作中定义了 查看(VIEW)，但是没有定义VIEW类型的sql语句，则可以拷贝UPDATEQUERY语句；如果UPDATEQUERY类型的SQL语句也没定义，则报错
		if (bizObject.getView() == 1) {
			if (StringUtils.isEmpty(bizObject.getViewSQL())) {
				if (StringUtils.isEmpty(bizObject.getUpdateQuerySQL())) {
					throw new ExceptionHandler(String.format("业务模型 %s[%s] 定义了业务操作：查看(VIEW)，但是没有定义VIEW(或UPDATEQUERY)的SQL语句！", bizObject.getName(), bizObject.getCode()));
				} else {
					bizObject.setViewSQL(bizObject.getUpdateQuerySQL());
					bizObject.getBizFieldsBind().put("VIEW_0", bizObject.getBizFieldsBind().get("UPDATEQUERY_0"));
				}
			}
		}

		return bizObject;
	}

	/**
	 * 解析字段定义<br>
	 * 业务模型中的字段实际来源于数据模型中，从属于一个或多个数据模型定义<br>
	 * 一般情况下业务模型文件中的字段配置只需要指定表名和字段名即可，其它属性定义会覆盖数据模型中的定义<br>
	 * 
	 * @param bizObject
	 *            业务模型对象
	 * @param map
	 *            以Fields为根的模型定义对象
	 * @return
	 * @throws ExceptionHandler
	 */
	@SuppressWarnings("unchecked")
	private static List<BizField> parseField(BizObject bizObject, Map<String, Object> map) throws ExceptionHandler {

		List<BizField> list = new ArrayList<BizField>();

		// 获取BizFields下的节点
		String tagName = null;
		String textContent = null;
		BizField bizField = null;
		Field baseField = null;
		FieldTemplate fieldTemplate = null;
		List<Map<String, Object>> tagList = null;
		List<Map<String, Object>> bizFieldList = (List<Map<String, Object>>) map.get(XMLHandler.CHILDREN_KEY);
		for (Map<String, Object> fieldTag : bizFieldList) {

			if (!"BizField".equalsIgnoreCase(fieldTag.get(XMLHandler.TAG_NAME_KEY).toString())) {
				continue;
			}

			bizField = new BizField();
			Reflect.initObject(bizField);// 初始化对象，继承自父类的整形字段设置为-1

			// 获取BizField下的节点，解析BizField属性
			tagList = (List<Map<String, Object>>) fieldTag.get(XMLHandler.CHILDREN_KEY);
			for (Map<String, Object> m : tagList) {
				tagName = (String) m.get(XMLHandler.TAG_NAME_KEY);
				textContent = (String) m.get(XMLHandler.TEXT_CONTENT);
				if ("Table".equalsIgnoreCase(tagName)) {
					// 所属表
					bizField.setTable(TableContainer.get(textContent));
				} else if ("FieldTemplate".equalsIgnoreCase(tagName)) {
					// 字段模板
					fieldTemplate = FieldTemplateContainer.get(textContent);
					if (fieldTemplate == null) {
						throw new ExceptionHandler(String.format("业务模型 %s[%s] 中业务字段 %s[%s] 引用的字段模板 %s 未定义", bizObject.getName(), bizObject.getCode(), bizObject.getName(), bizObject.getCode(),
								textContent));
					}
					try {
						bizField.setFieldTemplate(fieldTemplate.clone());
					} catch (CloneNotSupportedException e) {
					}
				} else {
					// 其它基本属性
					Util.dynamicAssignment(bizField, tagName, textContent);
				}
			}

			// 字段的属性以数据模型中的定义为基准，业务模型中的配置将覆盖数据模型中的定义
			if (bizField.getAlias() == null) {
				bizField.setAlias(bizField.getCode());// 业务模型字段名和数据模型字段名有可能不一致
			}

			// 业务字段来源于数据模型中定义
			if (bizField.getTable() != null) {
				baseField = bizField.getTable().getFieldByCode(bizField.getAlias());

				if (baseField != null) {
					// 要求业务模型中的字段必须来源于数据模型中的定义
					Reflect.copy(baseField, bizField);
				}
			} else {
				bizField.setTable(new Table());
			}

			list.add(bizField);
		}

		bizFieldList = null;
		tagList = null;
		fieldTemplate = null;
		baseField = null;
		bizField = null;
		textContent = null;
		tagName = null;

		return list;
	}

	/**
	 * 解析SQL
	 * 
	 * @param map
	 *            以Sql为根的模型定义对象
	 * @return
	 * @throws ExceptionHandler
	 */
	@SuppressWarnings("unchecked")
	private static Map<SQLType, String[]> parseSQL(Map<String, Object> map) throws ExceptionHandler {
		Map<SQLType, String[]> result = new HashMap<SQLType, String[]>();

		// 如果Sql节点下有值，默认为select语句
		Object selectObj = map.get(XMLHandler.TEXT_CONTENT);
		if (selectObj != null && !StringUtils.isEmpty(selectObj.toString())) {
			result.put(SQLType.SELECT, new String[] { selectObj.toString() });// select语句只支持一条SQL
		}

		// 解析子节点(如果有Select节点，会覆盖Sql节点下的直接select语句)
		String tagName = null;
		String textContent = null;
		SQLType sqlType = null;
		List<Map<String, Object>> children = (List<Map<String, Object>>) map.get(XMLHandler.CHILDREN_KEY);
		for (Map<String, Object> child : children) {
			tagName = child.get(XMLHandler.TAG_NAME_KEY).toString();
			try {
				sqlType = SQLType.valueOf(tagName.toUpperCase());
				if (sqlType != null) {
					textContent = child.get(XMLHandler.TEXT_CONTENT).toString();
					result.put(sqlType, textContent.split(";"));
				}
			} catch (IllegalArgumentException e) {
			}
		}

		children = null;
		sqlType = null;
		textContent = null;
		tagName = null;
		selectObj = null;

		return result;
	}

	/**
	 * 解析查询条件
	 * 
	 * @param bizObject
	 *            业务模型对象
	 * @param map
	 *            以QueryFields为根的模型定义对象
	 * @return
	 * @throws ExceptionHandler
	 */
	@SuppressWarnings("unchecked")
	private static List<QueryField> parseQueryField(BizObject bizObject, Map<String, Object> map) throws ExceptionHandler {

		List<QueryField> list = new ArrayList<QueryField>();

		// 获取QueryFields下的节点
		String tagName = null;
		String textContent = null;
		QueryField queryField = null;
		FieldTemplate fieldTemplate = null;
		List<Map<String, Object>> tagList = null;
		List<Map<String, Object>> queryFieldList = (List<Map<String, Object>>) map.get(XMLHandler.CHILDREN_KEY);
		for (Map<String, Object> fieldTag : queryFieldList) {

			if (!"QueryField".equalsIgnoreCase(fieldTag.get(XMLHandler.TAG_NAME_KEY).toString())) {
				continue;
			}

			queryField = new QueryField();
			Reflect.initObject(queryField);// 初始化对象，继承自父类的整形字段设置为-1

			// 获取QueryField下的节点，解析QueryField属性
			tagList = (List<Map<String, Object>>) fieldTag.get(XMLHandler.CHILDREN_KEY);
			for (Map<String, Object> m : tagList) {
				tagName = (String) m.get(XMLHandler.TAG_NAME_KEY);
				textContent = (String) m.get(XMLHandler.TEXT_CONTENT);
				if ("connector".equalsIgnoreCase(tagName)) {
					// 连接符
					queryField.setConnector(Connector.valueOf(textContent.toUpperCase()));
				} else if ("fieldtemplate".equalsIgnoreCase(tagName)) {
					// 字段模板
					fieldTemplate = FieldTemplateContainer.get(textContent);
					if (fieldTemplate == null) {
						throw new ExceptionHandler(String.format("业务模型 %s[%s] 中查询字段 %s[%s] 引用的字段模板 %s 未定义", bizObject.getName(), bizObject.getCode(), bizObject.getName(), bizObject.getCode(),
								textContent));
					}
					try {
						queryField.setFieldTemplate(fieldTemplate.clone());
					} catch (CloneNotSupportedException e) {
					}
				} else {
					// 其它基本属性
					Util.dynamicAssignment(queryField, tagName, textContent);
				}
			}

			list.add(queryField);
		}

		queryFieldList = null;
		tagList = null;
		fieldTemplate = null;
		queryField = null;
		textContent = null;
		tagName = null;

		return list;
	}

	/**
	 * 解析业务操作
	 * 
	 * @param bizObject
	 *            业务模型对象
	 * @param map
	 *            以BizProcess为根的模型定义对象
	 * @return
	 * @throws ExceptionHandler
	 */
	@SuppressWarnings("unchecked")
	private static List<BizProcess> parseBizProcess(BizObject bizObject, Map<String, Object> map) throws ExceptionHandler {

		List<BizProcess> list = new ArrayList<BizProcess>();

		// 获取BizProcess下的节点
		String tagName = null;
		String textContent = null;
		BizProcess bizProcess = null;
		List<Map<String, Object>> tagList = null;
		List<Map<String, Object>> bizProcessList = (List<Map<String, Object>>) map.get(XMLHandler.CHILDREN_KEY);
		for (Map<String, Object> processTag : bizProcessList) {

			if (!"BizProcess".equalsIgnoreCase(processTag.get(XMLHandler.TAG_NAME_KEY).toString())) {
				continue;
			}

			bizProcess = new BizProcess();
			Reflect.initObject(bizProcess);// 初始化对象，继承自父类的整形字段设置为-1

			// 获取BizProcess下的节点，解析BizProcess属性
			tagList = (List<Map<String, Object>>) processTag.get(XMLHandler.CHILDREN_KEY);
			for (Map<String, Object> m : tagList) {
				tagName = (String) m.get(XMLHandler.TAG_NAME_KEY);
				textContent = (String) m.get(XMLHandler.TEXT_CONTENT);
				// 基本属性
				Util.dynamicAssignment(bizProcess, tagName, textContent);
			}

			// 默认按钮图标
			if (StringUtils.isEmpty(bizProcess.getIconCls())) {
				if ("add".equals(bizProcess.getCode())) {
					bizProcess.setIconCls("icon-add");
				} else if ("mod".equals(bizProcess.getCode())) {
					bizProcess.setIconCls("icon-edit");
				} else if ("del".equals(bizProcess.getCode())) {
					bizProcess.setIconCls("icon-cancel");
				} else if ("view".equals(bizProcess.getCode())) {
					bizProcess.setIconCls("ext-icon-view");
				}
			}

			if (StringUtils.isEmpty(bizProcess.getCode()) || StringUtils.isEmpty(bizProcess.getName())) {
				throw new ExceptionHandler(String.format("业务模型：%s[%s] 中，业务过程：%s 缺少code或name！)", bizObject.getName(), bizObject.getCode(), bizProcess.toString()));
			}

			if (StringUtils.isEmpty(bizProcess.getUrl()) && StringUtils.isEmpty(bizProcess.getFunctionCall()) && StringUtils.isEmpty(bizProcess.getScript())) {
				throw new ExceptionHandler(String.format("业务模型：%s[%s] 中，业务过程：%s[%s] 缺少执行动作(url,functionCall,script 不能同时为空！)", bizObject.getName(), bizObject.getCode(), bizProcess.getName(),
						bizProcess.getCode()));
			}
			list.add(bizProcess);
		}

		bizProcessList = null;
		tagList = null;
		bizProcess = null;
		textContent = null;
		tagName = null;

		return list;
	}

	/**
	 * 绑定sql语句中的参数，同bizFields建立关系<br>
	 * sql语句中使用了特殊格式的占位符：@{业务字段名}
	 * 
	 * @param bizObject
	 *            业务模型对象
	 * @throws ExceptionHandler
	 */
	private static void bindSQLBizField(BizObject bizObject) throws ExceptionHandler {

		Map<SQLType, String[]> sqlMap = bizObject.getSql();
		Set<Entry<SQLType, String[]>> set = sqlMap.entrySet();
		Iterator<Entry<SQLType, String[]>> it = set.iterator();
		Entry<SQLType, String[]> entry = null;

		SQLType sqlType = null;

		String[] sqls = null;// 业务模型文件中定义的sql语句
		String sql = null;
		String[] prepareSQL = null;// 预处理语句

		BizField bizField = null;// 业务字段对象
		String bizFieldCode = null;// 业务模型字段名
		String fieldCode = null;// 数据模型字段名
		List<BizField> bindBizFields = null;

		StringBuilder sb = new StringBuilder();

		int beginIndex = 0;
		int endIndex = 0;
		int whereIndex = -1;

		while (it.hasNext()) {
			entry = it.next();
			sqlType = entry.getKey();

			if (sqlType.equals(SQLType.SELECT)) {
				continue;// 排除select语句
			}

			/**
			 * 根据bizObject中定义的 insertSQL,updateSQL,deleteSQL 和 bizFields 来提取页面上需要展现的字段 <br>
			 * sql语句中通过特定的格式来标明字段@{column}，其中column对应了fields中的同名字段
			 */
			// Step-1 从sql中获取占位字段
			sqls = entry.getValue();
			prepareSQL = new String[sqls.length];
			for (int i = 0; i < sqls.length; i++) {
				// 单条sql处理
				sql = sqls[i];
				sql = sql.toLowerCase();
				whereIndex = sql.indexOf("where");
				beginIndex = 0;
				endIndex = 0;
				bindBizFields = new ArrayList<BizField>();
				while ((beginIndex = sql.indexOf("@{")) != -1) {
					endIndex = sql.indexOf("}", beginIndex);
					if (endIndex == -1) {
						throw new ExceptionHandler(String.format("业务模型：%s[%s] 中，SQL中占位符不完整:%s", bizObject.getName(), bizObject.getCode(), sql));
					}

					bizFieldCode = sql.substring(beginIndex + 2, endIndex);// 字段占位符对应的业务字段code
					bizField = bizObject.getBizFieldByCode(bizFieldCode);// 取到对应的业务字段对象
					if (bizField == null) {
						throw new ExceptionHandler(String.format("业务模型： %s[%s] 中未定义字段：", bizObject.getName(), bizObject.getCode(), bizFieldCode));
					}

					if (sqlType.equals(SQLType.INSERT)) {
						bizField.setCanInsert(1);// 标记业务字段是增加字段
					} else if (sqlType.equals(SQLType.UPDATE)) {
						if (beginIndex < whereIndex) {
							// 位于 where 标记前面的字段才允许编辑
							bizField.setCanUpdate(1);// 标记业务字段是修改字段
						}
					}

					fieldCode = bizField.getAlias();// 找到业务字段对应的数据模型字段名

					// sql转换
					if (sqlType.equals(SQLType.INSERT)) {
						// 对于insert
						sql = sql.substring(0, beginIndex) + fieldCode + sql.substring(endIndex + 1);
					} else {
						// 对于update或delete
						if (beginIndex < sql.indexOf("where")) {
							sql = sql.substring(0, beginIndex) + fieldCode + "=?" + sql.substring(endIndex + 1);
						} else {
							sql = sql.substring(0, beginIndex) + "?" + sql.substring(endIndex + 1);
						}
					}

					bindBizFields.add(bizField);
				}

				// 单条sql字段绑定
				bizObject.getBizFieldsBind().put(sqlType.toString() + "_" + i, bindBizFields);

				// sql转换
				if (sqlType.equals(SQLType.INSERT)) {
					sb.delete(0, sb.length());
					sb.append(" values(");
					for (int j = 0; j < bindBizFields.size(); j++) {
						sb.append("?");
						if (j < bindBizFields.size() - 1) {
							sb.append(",");
						}
					}
					sb.append(")");
					sql += sb.toString();
					sb.delete(0, sb.length());
				}

				prepareSQL[i] = sql;

			}

			if (sqlType.equals(SQLType.INSERT)) {
				bizObject.setInsertSQL(prepareSQL);

				BizProcess add = new BizProcess();
				add.setOrderNum(1);
				add.setCode("add");
				add.setName("添加");
				add.setFunctionCall("add");
				add.setIconCls("icon-add");
				bizObject.addProcess(add);
				add = null;
			} else if (sqlType.equals(SQLType.UPDATE)) {
				bizObject.setUpdateSQL(prepareSQL);

				BizProcess mod = new BizProcess();
				mod.setOrderNum(2);
				mod.setCode("mod");
				mod.setName("修改");
				mod.setFunctionCall("mod");
				mod.setIconCls("icon-edit");
				bizObject.addProcess(mod);
				mod = null;
			} else if (sqlType.equals(SQLType.DELETE)) {
				bizObject.setDeleteSQL(prepareSQL);

				BizProcess del = new BizProcess();
				del.setOrderNum(3);
				del.setCode("del");
				del.setName("删除");
				del.setFunctionCall("del");
				del.setIconCls("icon-cancel");
				bizObject.addProcess(del);
				del = null;
			} else if (sqlType.equals(SQLType.UPDATEQUERY)) {
				bizObject.setUpdateQuerySQL(prepareSQL[0]);// 约定只有一条
			} else if (sqlType.equals(SQLType.VIEW)) {
				bizObject.setViewSQL(prepareSQL[0]);// 约定只有一条

				BizProcess view = new BizProcess();
				view.setOrderNum(4);
				view.setCode("view");
				view.setName("查看");
				view.setFunctionCall("view");
				view.setIconCls("icon-view");
				bizObject.addProcess(view);
				view = null;
			}

		}

		sb = null;

		sqls = null;
		sql = null;
		prepareSQL = null;

		bizField = null;
		bizFieldCode = null;
		fieldCode = null;
		bindBizFields = null;

		sqlType = null;
		entry = null;
		it = null;
		set = null;
		sqlMap = null;

	}
}
